# -*- coding: utf-8 -*-
"""
视频组数据模型
按基础番号和版本类型分组管理视频文件
"""
from dataclasses import dataclass, field
from enum import Enum
from typing import List, Dict, Optional
from .models import VideoInfo, VideoType


class VideoVariant(Enum):
    """视频版本类型"""
    BASE = "基础视频"           # 基础版本
    SUBTITLE = "字幕视频"       # 字幕版本 (-C)
    LEAK = "流出视频"          # 流出版本 (流出)
    FOUR_K = "4K视频"           # 4K版本 (4K)
    SEGMENT = "分段视频"        # 分段版本 (-CD数字)
    SUBTITLE_SEGMENT = "字幕分段视频"  # 字幕+分段 (-C-CD数字)
    LEAK_SEGMENT = "流出分段视频"     # 流出+分段 (流出-CD数字)


@dataclass
class VideoVariantGroup:
    """视频版本组 - 同一基础番号下的同一版本类型"""
    
    # 基础信息
    base_id: str                    # 基础番号 (如 FC2-3284333)
    variant_type: VideoVariant      # 版本类型
    video_type: VideoType          # 视频类型 (FC2/有码/无码)
    
    # 文件列表
    files: List[VideoInfo] = field(default_factory=list)
    
    def add_file(self, video_info: VideoInfo) -> None:
        """添加文件到当前版本组"""
        if video_info not in self.files:
            self.files.append(video_info)
    
    @property
    def file_count(self) -> int:
        """文件数量"""
        return len(self.files)
    
    @property
    def file_names(self) -> List[str]:
        """获取所有文件名"""
        return [video.original_filename for video in self.files]
    
    def __str__(self) -> str:
        return f"{self.variant_type.value}: {self.file_count}个文件"


@dataclass 
class VideoGroup:
    """视频组 - 同一基础番号下的所有版本"""
    
    # 基础信息
    base_id: str                    # 基础番号
    video_type: VideoType          # 视频类型
    
    # 版本组字典
    variants: Dict[VideoVariant, VideoVariantGroup] = field(default_factory=dict)
    
    def add_video(self, video_info: VideoInfo) -> None:
        """添加视频到对应的版本组"""
        variant_type = self._determine_variant_type(video_info)
        
        if variant_type not in self.variants:
            self.variants[variant_type] = VideoVariantGroup(
                base_id=self.base_id,
                variant_type=variant_type,
                video_type=self.video_type
            )
        
        self.variants[variant_type].add_file(video_info)
    
    def _determine_variant_type(self, video_info: VideoInfo) -> VideoVariant:
        """确定视频的版本类型"""
        has_subtitle = video_info.has_subtitle
        has_segment = video_info.is_segment
        has_leak = video_info.has_leak
        has_4k = video_info.has_4k
        
        # 组合判断 (分段优先)
        if has_subtitle and has_segment:
            return VideoVariant.SUBTITLE_SEGMENT
        elif has_leak and has_segment:
            return VideoVariant.LEAK_SEGMENT
        
        # 单独判断 (按优先级)
        if has_segment:
            return VideoVariant.SEGMENT
        if has_4k:
            return VideoVariant.FOUR_K
        if has_subtitle:
            return VideoVariant.SUBTITLE
        if has_leak:
            return VideoVariant.LEAK
        
        # 默认基础版本
        return VideoVariant.BASE
    
    @property
    def total_files(self) -> int:
        """总文件数"""
        return sum(variant.file_count for variant in self.variants.values())
    
    @property
    def variant_count(self) -> int:
        """版本类型数量"""
        return len(self.variants)
    
    @property
    def has_duplicates(self) -> bool:
        """是否存在重复（有多种版本类型即为重复组）"""
        return self.variant_count > 1
    
    def get_variant_summary(self) -> Dict[str, int]:
        """获取版本类型摘要"""
        return {
            variant.variant_type.value: variant.file_count 
            for variant in self.variants.values()
        }
    
    def __str__(self) -> str:
        return f"VideoGroup({self.base_id}: {self.variant_count}种版本, {self.total_files}个文件)"

    def get_all_files(self) -> List[VideoInfo]:
        """获取该组内所有版本的所有文件"""
        all_files = []
        for variant_group in self.variants.values():
            all_files.extend(variant_group.files)
        return all_files